
package com.gkj.gulimall.product.javabase;

import lombok.Synchronized;
import lombok.val;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.w3c.dom.NodeList;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    public static void main(String[] args) {
        try {
            test();
            System.out.println("A");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("B");
            return;
        } catch (Exception e) {
            System.out.println("C");
        } finally {
            System.out.println("D");
        }
    }

    private static void test() {
        int[] a = {1, 2, 4};
        System.out.println(a[3]);
    }

}

class Base {
    // 1.父类静态代码块
    static {
        System.out.println("Base static block!");
    }

    // 3.父类非静态代码块
    {
        System.out.println("Base block");
    }

    // 4.父类构造器
    public Base() {
        System.out.println("Base constructor!");
    }
}

/**
 * Java 反射机制可以动态地创建对象并调用其属性 --重点：是运行时而不是编译时
 */
class Derived extends Base {
    int age = 0;

    // 2.子类静态代码块
    static {
        System.out.println("Derived static block!");
    }

    // 5.子类非静态代码块
    {
        System.out.println("Derived block!");
    }

    // 6.子类构造器
    public Derived() {
        System.out.println("Derived constructor!");
    }

    public static void main(String[] args) {
        new Derived();
        Class clazz = Derived.class;
        System.out.println(clazz);
        int a = 1, b = 2;
        System.out.println("a + b = " + a + b);
    }
}

class Box<T> {//定义泛型类
    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box();
        Box<String> stringBox = new Box<String>();

        integerBox.add(new Integer(10));
        stringBox.add(new String("菜鸟教程"));

        System.out.printf("整型值为 :%d\n\n", integerBox.get());
        System.out.printf("字符串为 :%s\n", stringBox.get());
    }
}

class NameList {
    private List names = new ArrayList();

    public synchronized void add(String name) {
        names.add(name);
    }

    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++) {
            System.out.print(names.get(i) + "");
        }


        //byte short char自动转换int类型
        //final不会自动转换
        byte b1 = 1, b2 = 2, b3, b6, b8;
        final byte b4 = 4, b5 = 6, b7;
        b3 = (byte) (b1 + b2);  /*语句1*/
        b6 = b4 + b5;    /*语句2*/
        b8 = (byte) (b1 + b4);  /*语句3*/
        b7 = (byte) (b2 + b5);  /*语句4*/
        System.out.println(b3 + b6);
    }

    public static void main(String[] args) {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                sl.add("A");
                sl.add("B");
                sl.add("C");
                sl.printAll();
            }).start();
        }
        System.out.println(Math.round(-11.5));
        System.out.println(Math.round(11.5));

    }
}

class Arraytest {
    static int a[] = new int[6];
    static String str = "abc";

    public static void main(String arg[]) {
//        System.out.println ( a.hashCode() );
//        int a = 1;Integer b = 1;
//        System.out.println(a == b);
//        int count = findEvenNumber("abcxyz");
//        System.out.println(count);
        int[] merge = arrayMerge(5, new int[]{4, 1, 35, 36, 3}, 4, new int[]{245, 8, 5, 2});
        for (int i : merge) {
            System.out.println("合并后数组的值: " + i);
        }

    }

    public static int[] arrayMerge(int m, int[] array, int n, int[] array2) {//数组的合并操作
        Arrays.sort(array);//对数组进行升序
        Arrays.sort(array2);
        Collections.reverse(Arrays.asList(array2.clone()));//升序完的数组做逆转得到数组的倒序
        int[] newArr = Arrays.copyOf(array, (m + n));
        int j = 0;
        for (int i = m; i < (m + n); i++) {
            newArr[i] = array2[j];
            j++;
        }
        Arrays.sort(newArr);
        return newArr;
    }

    public static void testStr(String str) {

        Arraytest.str = str;
        System.out.println(str);
    }

    public static int findEvenNumber(String str) {
        HashSet<Character> set = new HashSet<>();
        for (int i = 0; i < str.length(); i++) {
            if (!set.contains(str.charAt(i))) {
                set.add(str.charAt(i));
            } else {
                return (i + 1);
            }
        }
        return 0;
    }
}

class Base2 {
    private String baseName = "base";

    public Base2() {
        callName();
    }

    public void callName() {
        System.out.println(baseName);
    }

    static class Sub extends Base2 {
        private String baseName = "sub";

        public void callName() {
            System.out.println(baseName);
        }
    }

    public static void main(String[] args) {
        Base2 b = new Sub();
        b.callName();
    }
}

class Niuke extends Thread {
    public void test() {
        Niuke niuke = new Niuke();
        niuke.run();
        niuke.start();
        Collections.reverse(new ArrayList<>());

        String x = "fmn";
        x.toUpperCase();
        String y = x.replace('f', 'F');
        y = y + "wxy";
        System.out.println(y);
    }

}

class Example {
    String str = new String("good");
    char[] ch = {'a', 'b', 'c'};

    public static void main(String[] args) {
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        Example ex = new Example();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + "and");
        System.out.print(ex.ch);
    }

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'g';
    }

    public synchronized void change2() {

    }
}

interface A extends B, C {//接口允许多继承

}

interface B {

}

interface C {

}

class Car extends Vehicle {
    public static void main(String[] args) {

//        new  Car(). run();
        Object o1 = true ? new Integer(1) : new Double(2.0);
        Object o2;
        if (true) {
            o2 = new Integer(1);
        } else {
            o2 = new Double(2.0);
        }
        System.out.print(o1);
        System.out.print(" ");
        System.out.print(o2);

    }

    @Override
    void run() {
        System.out.println("Car");
    }
}

class Vehicle {
    void run() {
        System.out.println("Vehicle");
    }
}

class StringDemo {
    private static final String MESSAGE = "taobao";

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    public static void main(String[] args) {
        /**
         * 字面量"+"拼接是在编译期间进行的，拼接后的字符串存放在字符串池中；而字符串引用的"+"拼接运算实在运行时进行的，新创建的字符串存放在堆中
         */
        String a = "tao" + "bao";//发生在编译时期，字面量的拼接，拼接后放到字符串常量池
        String b = "tao";
        String c = "bao";
        String d = "";
        System.out.println(a == MESSAGE);

        System.out.println((b + c) == MESSAGE);//相当于是new StringBuilder(c + b),所以对象的引用不同
    }
}

class ResultMap<K, V> {
    K key;
    V value;

    public void put(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

class father implements Cloneable {
    public int age;
    public String nation = "";
    public son son1;
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        father father1 = (father) super.clone();
//        son1 = (son) this.son1.clone();
//        return father1;
//    }

    public void initial(int age, String nation) {
        this.age = age;
        this.nation = nation;
    }
}

class son extends father {
    public static void main(String[] args) {
        son son1 = new son();
        try {
            son son2 = (son) son1.clone();
            son son3 = son1;
            System.out.println(son1 == son2);
            System.out.println(son1 == son3);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

        }
    }
}

class OuterClass {
    private String str;
    private static int age;

    public void outerDisplay() {
        System.out.println("outerClass...");
    }

    public class InnerClass {
        public void innerDisplay() {
            age = 20;
            str = "chenssy..."; //使用外围内的属性
            System.out.println(str);
            System.out.println(age);
            outerDisplay();  //使用外围内的方法
        }
    }

    // 推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时
    InnerClass getInnerClass() {
        return new InnerClass();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();//先创建外部类的对象
        OuterClass.InnerClass inner = outer.getInnerClass();//通过外部类的对象去访问内部类的成员
        inner.innerDisplay();
    }
}


//定义在作用域内:
class Parcel6 {
    private void internalTracking(boolean b) {
        if (b) {
            class TrackingSlip {//局部内部类
                private String id;

                TrackingSlip(String s) {
                    id = s;
                }

                String getSlip() {
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("chenssy");
            String string = ts.getSlip();
        }
    }

    public void track() {
        internalTracking(true);
    }

    public static void main(String[] args) {
        Parcel6 parcel6 = new Parcel6();
        parcel6.track();
        System.out.println(true || false);
    }
}

class D {
    private int x;        // 实例变量
    public static int y;  // 静态变量
}

/**
 * 隔离级别
 * Read Uncommitted（读未提交）：能够读取到没有被提交的数据
 * <p>
 * Read Committed（读已提交）：能够读到那些已经提交的数据
 * <p>
 * Repeatable Read（可重复读）：在数据读出来之后加锁，即读取了一条数据，这个事务不结束，别的事务就不可以改这条记录
 * <p>
 * Serializable（串行化）：不管多少事务，都要以串行的形式一个一个执行
 * <p>
 * <p>
 * 匿名内部类也就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
 * <p>
 * <p>
 * 成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问
 * <p>
 * <p>
 * 向上造型和向下造型
 * 父类引用能指向子类对象，子类引用不能指向父类对象；
 * <p>
 * 1. 静态变量
 * <p>
 * 静态变量在内存中只存在一份，只在类初始化时赋值一次。
 * <p>
 * . 静态语句块
 * <p>
 * 静态语句块在类初始化时运行一次
 * <p>
 * 静态方法
 * <p>
 * 静态方法在类加载的时候就存在了，它不依赖于任何实例，所以静态方法必须有实现，也就是说它不能是抽象方法（abstract）
 * <p>
 * 解决hash冲突的办法 --链地址法
 * 就是把某个数据经过hash算法得到的hash值和之前的put进去的元素key算出来的hash值冲突了，此时就把这个重复的hash值放到数组中已经存在的位置，以链表的形式进行连接
 * ，以后需要取的时候就可以对该链表进行遍历,最坏情况去到O(n)。
 * <p>
 * ArrayList、LinkedList 和 Vector如何选择？
 * <p>
 * 当对数据的主要操作为索引或只在集合的末端增加、删除元素时，使用 ArrayList 或 Vector 效率比较高；
 * 当对数据的操作主要为指定位置的插入或删除操作时，使用 LinkedList 效率比较高；
 * 当在多线程中使用容器时（即多个线程会同时访问该容器），选用 Vector 较为安全；
 * Hash冲突的解决办法
 * 链地址法
 * 开放地址法（向后一位）
 * 线性探测
 * 平方探测
 * 二次哈希
 * 再哈希法
 *
 * TCP和UDP区别
 * UDP 是无连接的，即发送数据之前不需要建立连接。
 * UDP  使用尽最大努力交付，即不保证可靠交付，同时也不使用拥塞控制。
 * UDP 是面向报文的。UDP 没有拥塞控制，很适合多媒体通信的要求。
 * UDP 支持一对一、一对多、多对一和多对多的交互通信。
 * UDP 的首部开销小，只有 8 个字节。
 * TCP 是面向连接的运输层协议。
 * 每一条 TCP 连接只能有两个端点(endpoint)，每一条 TCP 连接只能是点对点的（一对一）。
 * TCP 提供可靠交付的服务。
 * TCP  提供全双工通信。
 * TCP是面向字节流。  
 * 首部最低20个字节。
 */

class MyRunnable extends Thread implements Runnable {
    public void run() {
        test();
    }
    int count;
    public int[] multiply(int[] A) {
        int count = 1;
        if(A.length == 1)
            return new int[0];
        int B[] = new int[A.length];
        for (int i = 0;i < A.length;i++){
            B[i] = 1;
        }
        for(int i = 1;i < B.length;i++){
            B[i] =  B[i - 1] * A[i - 1];
        }
        for(int i = B.length - 2;i >= 0;i--){
            count *= A[i + 1];
            B[i] *= count;
        }
        return B;
    }
    //排序，使得数组的奇数位于偶数之前
    public static int[] reOrderArrayTwo (int[] array) {
        // write code here

//        int even[] = new int[array.length];
//        int odd[] = new int[]{};
        /**
         * 首先创建两个集合用于保存奇数和偶数，判断相应的奇偶数后加入相应的集合
         * ，然后奇数集合加入偶数，就达到题目要求的奇数位于偶数之前
         */
        ArrayList<Integer> odd = new ArrayList<>();
        ArrayList<Integer> even = new ArrayList<>();
        for(int i = 0,j = 0,k = 0;i < array.length;i++){
            if(array[i] % 2 == 0){
                even.add(array[i]);
            }else{
                odd.add(array[i]);
            }
        }
        for (Integer even1 : even) {
            odd.add(even1);
        }
        for(int i = 0;i < odd.size();i++){
            array[i] = odd.get(i);
        }
        return array;
    }

    public void test() {
        synchronized (this) {//加上对象锁
            for (int i = 0; i < 5; i++) {
                System.out.println("线程名:" + this.getName() + " i: " + i);
            }
        }
//        synchronized (MyRunnable.class){//给类对象加锁，类的所有实例都共享这一把锁
//            for(int i = 0;i < 5;i++)
//            {
//                System.out.println("线程名:"+this.getName()+" i: "+i);
//            }
//        }
    }
    public static int[] printNumbers (int n) {
        // write code here
        int temp = 0;int [] res = {};
        switch(n){
            case 1:temp = 9;break;
            case 2:temp = 99;break;
            case 3:temp = 999;break;
            case 4:temp = 9999;break;
            default:temp =99999;
        }
        res = new int[temp];
        for(int i = 1;i <= temp;i++){
            res[i - 1] = i;
        }
        return res;
    }

    public static int duplicate(int[] numbers) {
        HashSet<Integer> set = new HashSet<>();//特点：无序且不重复
        int repeat = 0;
        if(numbers.length == 0)
            return 0;
        for (int i =0;i < numbers.length;i++){
            if(set.add(numbers[i])){//map.put(e,PERSENT)
                continue;
            }else{
                repeat = numbers[i];
                break;
            }
        }
        return repeat;
    }

    /**
     *
     * @param matrix
     * @return
     *
     * [[1, 2, 3, 4],
     * [5,6,7,8],
     * [9,10,11,12],
     * [13,14,15,16]]
     */
    public static ArrayList<Integer> printMatrix(int [][] matrix) {
        int maxCircle = 2,point = 0,point2= 0;
        List<Integer> list = new ArrayList<>();
        for(int i = 0;i < matrix.length;i++){
            for(int j = i;j < matrix[0].length;j++){
                list.add(matrix[point][point2]);
                if(point2 == matrix[0].length){
                    point++;
                }
                if(point == matrix.length){
                    point2--;
                }
            }
        }
        return (ArrayList<Integer>) list;
    }

    public static ListNode Merge(ListNode list1,ListNode list2) {
        //合并两个排序的链表
//        TreeMap<Integer, ListNode> treeMap = new TreeMap<>();
        /**
         * 第一步创建List集合储存两个列表的val值，最后对集合做一个升序排列
         * 第二部创建ListNode节点存第一个节点对象，然后再创建一个临时节点对象存储第一个节点对象
         * 第三步开始遍历List集合的元素创建排序好的节点对象
         */
        List<Integer> sort = new ArrayList<>();
        if(list1 == null || list2 == null)
            return null;
        if(list1 != null && list2 == null)
            return list1;
        if(list2 != null && list1 == null)
            return list2;
        while(list1 != null){
            sort.add(list1.val);
            list1 = list1.next;
        }
        while(list2 != null) {
            sort.add(list2.val);
            list2 = list2.next;
        }
        Collections.sort(sort);
        ListNode node = new ListNode(sort.get(0));
        ListNode temp = node;
        for(int i = 1;i < sort.size();i++){
            temp.next = new ListNode(sort.get(i));
            temp = temp.next;
        }
//        Set<Integer> set = treeMap.keySet();
//        ListNode [] node = new ListNode[set.size()];
//        int count = 0;
//        for (Integer integer : set) {
//            ListNode listNode = treeMap.get(integer);
//            node[count++] = listNode;
//        }
//
//        ListNode node1 = new ListNode(node[0].val);
//        ListNode temp = node1;
//        for(int i = 1;i < node.length;i++){
//            temp.next = node[i];
//            temp = temp.next;
//        }
        return node;
    }

    public static void main(String[] args) {

//        ArrayList<Integer> list = printMatrix(new int[][]{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}});
        int [][] a = new int[][]{{1,2,3,4},{4,5,6},{7,8,9}};

        for(int i = 0;i < a.length;i++){//遍历行
            for (int j = 0;j < a[i].length;j++){//遍历每列的元素
                System.out.println(a[i][j]);
            }
        }
        System.out.println("========");
        int[] arrayTwo = reOrderArrayTwo(new int[]{1,3,5,6,7});
        for(int i = 0;i < arrayTwo.length;i++){
            System.out.println(arrayTwo[i]);
        }
        System.out.println("==========");
//        int[] numbers = printNumbers(2);
//        for (int i : numbers) {
//            System.out.println(i);
//        }
        int duplicate = duplicate(new int[]{2,3,1,0,2,5,3});
        System.out.println(duplicate);

//        ExecutorService executorService = Executors.newCachedThreadPool();//创建线程池对象
//        MyRunnable myRunnable = new MyRunnable();
//        executorService.execute(myRunnable);
//        executorService.execute(myRunnable);

//        Thread thread1 = new Thread(myRunnable);
//        Thread thread2 = new Thread(myRunnable);
//        Thread thread3 = new Thread(myRunnable);
//        thread1.start();
//        thread2.start();
//        thread3.start();
//        StringBuffer buffer = new StringBuffer("aa");
//        buffer.append(10);
//        System.out.println(buffer);
    }
}

class foo {
    public static void main(String sgf[]) {

        StringBuffer a = new StringBuffer("A");

        StringBuffer b = new StringBuffer("B");

        operate(a, b);

        System.out.println(a + "." + b);
    }

    static void operate(StringBuffer x, StringBuffer y) {
        x.append(y);
        y = x;
//       y.append(x);
    }
}

class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }

    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        node1.next = node2;
        node2.next = node3;
        for(;;){
            if(node1 != null){
                System.out.println(node1.val);
            }else{
                System.out.println(node1.val);
                return;
            }
            node1 = node1.next;
        }
    }
}
class print implements Runnable{
    public static int count = 0;
    @Override
    public void run() {
        synchronized (this){
            if(count == 0){
                odd();
                count++;
            }else{
                even();
            }
        }
    }
    public void odd(){
        for(int i = 1;i <= 10;i++){
            if(i % 2 != 0)
                System.out.println("基数:"+i);
        }
    }
    public void even(){
        for (int i = 1;i <= 10;i++){
            if(i % 2 == 0)
                System.out.println("偶数:"+i);
        }
    }

    public static void main(String[] args) {
        print p1 = new print();
        Thread thread = new Thread(p1);
        Thread thread2 = new Thread(p1);
        thread.start();
        thread2.start();
    }

}
class Book {
    public static void main(String[] args) {
//        Map<String, Integer> map = new HashMap<>();
//        map.put("a2", 100);
//        map.put("a1", 100);
//        map.put("b", 300);
//        map.put("c", 200);
//        System.out.println(new Book().test(10));
        boolean isPopOrder = new Book().IsPopOrder(new int[]{1, 2, 3, 4, 5}, new int[]{5, 4, 3, 2, 1});
        System.out.println(isPopOrder);
    }
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        Stack<Integer> stack = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        boolean flag = false;
        for(int i=  0;i < pushA.length;i++){
            stack.push(pushA[i]);
            if(stack.get(i) == popA[i])
                flag = true;
            return flag;
        }
        for(int i = 0;i < stack.size();i++){
            for(int j = 0;j < stack.size();j++){
                
            }
        }
        return flag;
    }

    public int test(int n) {
        if(n == 0 || n == 1)
            return 1;
        return n * test(n - 1);

    }
}
class Singleton{
    int age = 0;
    static int gender = 1;
    //懒汉式 --存在线程安全问题
    private Singleton(){

    }
    public static Singleton getSingletonInstance(){
        return new Singleton();
    }

    public static void main(String[] args) {
        Singleton singletonInstance = Singleton.getSingletonInstance();
        singletonInstance.age = 10;
    }
}


